home *** CD-ROM | disk | FTP | other *** search
/ Aminet 28 / Aminet 28 (1998)(GTI - Schatztruhe)[!][Dec 1998].iso / Aminet / game / board / Exchess.lha / EXChess / pcapts.cpp < prev    next >
C/C++ Source or Header  |  1998-08-22  |  9KB  |  313 lines
  1. /* Piece captures only */
  2.  
  3. #include "chess.h"
  4. #include "define.h"
  5. #include "const.h"
  6. #include "funct.h"
  7.  
  8. /* Add capture function */
  9. // Function to add a capture to the capture list
  10. // The move is also scored for the alpha-beta search
  11. // fsq = from square,  tsq = to square
  12. void add_capt(position *p, int fsq, int tsq, move_list *list, char type)
  13. {
  14.   int i = list->count;      // index of move list
  15.  
  16.   // add move to list...
  17.   list->mv[i].m.b.from = fsq;
  18.   list->mv[i].m.b.to = tsq;
  19.   list->mv[i].m.b.type = type;
  20.   list->mv[i].m.b.promote = 0;
  21.  
  22.   // score move with the expected gain ....
  23.   list->mv[i].score = value[p->sq[tsq].type]; //-value[p->sq[fsq].type]/10;
  24.  
  25.   // if the move also promotes...
  26.   if((tsq > 55 || tsq < 8) && p->sq[fsq].type == PAWN)
  27.   {
  28.     list->mv[i].m.b.type |= PROMOTE; list->mv[i].m.b.promote = QUEEN;
  29.     list->mv[i].score += 1000;
  30.   }
  31.  
  32.   // if the square is defended, subtract value of moved piece
  33.   if(attacks(tsq, p, p->wtm^1, 1))
  34.    list->mv[i].score -= value[p->sq[fsq].type];
  35.  
  36.   list->count++;           // increase list count
  37. }
  38.  
  39. /*---------------------------- Bishop Captures --------------------------*/
  40. void bishop_capts(position *p, move_list *list, int sq)
  41. {
  42.   int mm, nn, ii, self;
  43.   int tsq;                          // to square
  44.  
  45.   mm = FILE(sq); nn = RANK(sq);     // set rank and file of bishop
  46.   self = p->wtm;                    // set side on move
  47.  
  48.   ii = 1;
  49.   while (mm + ii <= 7 && nn + ii <= 7)
  50.   {
  51.    tsq = SQR((mm+ii),(nn+ii));                // set to square
  52.    if (!p->sq[tsq].type) { ii++; }            // if empty, move on
  53.    else if (p->sq[tsq].side != self)          // else if other side,
  54.    { add_capt(p, sq, tsq, list, 1); break; }  // add to capture list
  55.    else break;                                // break if our piece
  56.   }
  57.  
  58.   ii = 1;
  59.   while (mm - ii >= 0 && nn + ii <= 7)
  60.   {
  61.    tsq = SQR((mm-ii),(nn+ii));
  62.    if (!p->sq[tsq].type) { ii++; }
  63.    else if (p->sq[tsq].side != self)
  64.    { add_capt(p, sq, tsq, list, 1); break; }
  65.    else break;
  66.   }
  67.  
  68.   ii = 1;
  69.   while(mm + ii <= 7 && nn - ii >= 0)
  70.   {
  71.    tsq = SQR((mm+ii),(nn-ii));
  72.    if (!p->sq[tsq].type) { ii++; }
  73.    else if (p->sq[tsq].side != self)
  74.    { add_capt(p, sq, tsq, list, 1); break; }
  75.    else break;
  76.   }
  77.  
  78.   ii = 1;
  79.   while (mm - ii >= 0 && nn - ii >= 0)
  80.   {
  81.    tsq = SQR((mm-ii),(nn-ii));
  82.    if (!p->sq[tsq].type) { ii++; }
  83.    else if (p->sq[tsq].side != self)
  84.    { add_capt(p, sq, tsq, list, 1); break; }
  85.    else break;
  86.   }
  87.  
  88. }
  89.  
  90. /*--------------------------- Rook Captures ---------------------------*/
  91. void rook_capts(position *p, move_list *list, int sq)
  92. {
  93.   int mm, nn, ii, self;
  94.   int tsq;                              // to square
  95.  
  96.   mm = FILE(sq); nn = RANK(sq);         // set file and rank of rook
  97.   self = p->wtm;                        // set side to move
  98.  
  99.   ii = 1;
  100.   while (mm + ii <= 7)
  101.   {
  102.    tsq = SQR((mm+ii),nn);                     // set to square
  103.    if (!p->sq[tsq].type) { ii++; }            // if empty, move on
  104.    else if (p->sq[tsq].side != self)          // else if other side,
  105.    { add_capt(p, sq, tsq, list, 1); break; }  // add to capture list
  106.    else break;                                // else if our side, break
  107.   }
  108.  
  109.   ii = 1;
  110.   while (mm - ii >= 0)
  111.   {
  112.    tsq = SQR((mm-ii),nn);
  113.    if (!p->sq[tsq].type) { ii++; }
  114.    else if (p->sq[tsq].side != self)
  115.    { add_capt(p, sq, tsq, list, 1); break; }
  116.    else break;
  117.   }
  118.  
  119.   ii = 1;
  120.   while(nn - ii >= 0)
  121.   {
  122.    tsq = SQR(mm,(nn-ii));
  123.    if (!p->sq[tsq].type) { ii++; }
  124.    else if (p->sq[tsq].side != self)
  125.    { add_capt(p, sq, tsq, list, 1); break; }
  126.    else break;
  127.   }
  128.  
  129.   ii = 1;
  130.   while (nn + ii <= 7)
  131.   {
  132.    tsq = SQR(mm,(nn+ii));
  133.    if (!p->sq[tsq].type) { ii++; }
  134.    else if (p->sq[tsq].side != self)
  135.    { add_capt(p, sq, tsq, list, 1); break; }
  136.    else break;
  137.   }
  138.  
  139. }
  140.  
  141. /*--------------------------- Knight Captures ----------------------------*/
  142. void knight_capts(position *p, move_list *list, int sq)
  143. {
  144.   int self = p->wtm;                         // set side to move
  145.   int tsq;                                   // to square
  146.  
  147.   if(FILE(sq) < 6 && RANK(sq) < 7) {
  148.    tsq = sq + 10;                                         // set to square
  149.    if(p->sq[tsq].side != self) {                          // if occupied by
  150.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);   // other side, add
  151.     }                                                     // to capture list
  152.   }
  153.   if(FILE(sq) < 6 && RANK(sq)) {
  154.    tsq = sq - 6;
  155.    if(p->sq[tsq].side != self) {
  156.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  157.     }
  158.   }
  159.   if(FILE(sq) > 1 && RANK(sq) < 7) {
  160.    tsq = sq + 6;
  161.    if(p->sq[tsq].side != self) {
  162.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  163.     }
  164.   }
  165.   if(FILE(sq) > 1 && RANK(sq)) {
  166.    tsq = sq - 10;
  167.    if(p->sq[tsq].side != self) {
  168.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  169.     }
  170.   }
  171.   if(FILE(sq) < 7 && RANK(sq) < 6) {
  172.    tsq = sq + 17;
  173.    if(p->sq[tsq].side != self) {
  174.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  175.     }
  176.   }
  177.   if(FILE(sq) && RANK(sq) < 6) {
  178.    tsq = sq + 15;
  179.    if(p->sq[tsq].side != self) {
  180.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  181.     }
  182.   }
  183.   if(FILE(sq) < 7 && RANK(sq) > 1) {
  184.    tsq = sq - 15;
  185.    if(p->sq[tsq].side != self) {
  186.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  187.     }
  188.   }
  189.   if(FILE(sq) && RANK(sq) > 1) {
  190.    tsq = sq - 17;
  191.    if(p->sq[tsq].side != self) {
  192.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  193.     }
  194.   }
  195.  
  196. }
  197.  
  198. /*--------------------------- King Captures ----------------------------*/
  199. void king_capts(position *p, move_list *list, int sq)
  200. {
  201.   int self = p->wtm;                     // set side to move
  202.   int tsq;                               // to square
  203.  
  204.   if(FILE(sq) && RANK(sq) < 7) {
  205.    tsq = sq + 7;                                         // set to square
  206.    if(p->sq[tsq].side != self) {                         // if occupied by
  207.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);  // other side, add
  208.     }                                                    // to capture list
  209.   }
  210.   if(RANK(sq) < 7) {
  211.    tsq = sq + 8;
  212.    if(p->sq[tsq].side != self) {
  213.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  214.     }
  215.   }
  216.   if(FILE(sq) < 7 && RANK(sq) < 7) {
  217.    tsq = sq + 9;
  218.    if(p->sq[tsq].side != self) {
  219.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  220.     }
  221.   }
  222.   if(FILE(sq)) {
  223.    tsq = sq - 1;
  224.    if(p->sq[tsq].side != self) {
  225.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  226.     }
  227.   }
  228.   if(FILE(sq) < 7) {
  229.    tsq = sq + 1;
  230.    if(p->sq[tsq].side != self) {
  231.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  232.     }
  233.   }
  234.   if(FILE(sq) < 7 && RANK(sq)) {
  235.    tsq = sq - 7;
  236.    if(p->sq[tsq].side != self) {
  237.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  238.     }
  239.   }
  240.   if(RANK(sq)) {
  241.    tsq = sq - 8;
  242.    if(p->sq[tsq].side != self) {
  243.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  244.     }
  245.   }
  246.   if(FILE(sq) && RANK(sq)) {
  247.    tsq = sq - 9;
  248.    if(p->sq[tsq].side != self) {
  249.      if(p->sq[tsq].type) add_capt(p, sq, tsq, list, 1);
  250.     }
  251.   }
  252. }
  253.  
  254. /*------------------------ Pawn Captures ------------------------------*/
  255. // Not including en passant!
  256. // Do include promotions!
  257. void pawn_capts(position *p, move_list *list, int sq)
  258. {
  259.   int self = p->wtm;                  // set side to move
  260.  
  261.   if(p->wtm) {                        // if it is white's pawn
  262.    if(FILE(sq)) {
  263.     if (p->sq[sq+7].type && p->sq[sq+7].side != self)
  264.       { add_capt(p, sq, sq+7, list, (PAWN_PUSH|1)); }  
  265.    }
  266.    if(FILE(sq) < 7) {
  267.     if (p->sq[sq+9].type && p->sq[sq+9].side != self)
  268.       { add_capt(p, sq, sq+9, list, (PAWN_PUSH|1)); }
  269.    }
  270.    if(RANK(sq) == 6) {
  271.     if (!p->sq[sq+8].type)
  272.       { add_capt(p, sq, sq+8, list, (PAWN_PUSH|PROMOTE)); }
  273.    }
  274.   } else {                           // or if it is black's pawn
  275.    if(FILE(sq)) {
  276.     if (p->sq[sq-9].type && p->sq[sq-9].side != self)
  277.       { add_capt(p, sq, sq-9, list, (PAWN_PUSH|1)); }
  278.    }
  279.    if(